package org.osiris.server;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.apache.log4j.Logger;
import org.osiris.client.model.CategoriaViewBean;
import org.osiris.client.model.ComplejidadrequisitoViewBean;
import org.osiris.client.model.EstadorequisitoViewBean;
import org.osiris.client.model.IncertidumbreViewBean;
import org.osiris.client.model.PrioridadViewBean;
import org.osiris.client.model.ProyectoViewBean;
import org.osiris.client.model.TipoRecursoViewBean;
import org.osiris.client.model.TipoRequisitoViewBean;
import org.osiris.client.model.UsuarioViewBean;
import org.osiris.client.services.ComboService;
import org.osiris.persistence.Categoria;
import org.osiris.persistence.Complejidadrequisito;
import org.osiris.persistence.Estadorequisito;
import org.osiris.persistence.Incertidumbre;
import org.osiris.persistence.Prioridadrequisito;
import org.osiris.persistence.Proyecto;
import org.osiris.persistence.Subcategoria;
import org.osiris.persistence.Tiporequisito;
import org.osiris.persistence.Usuario;
import org.osiris.persistence.controllers.CategoriasInterface;
import org.osiris.persistence.controllers.ComplejidadInterface;
import org.osiris.persistence.controllers.EstadoInterface;
import org.osiris.persistence.controllers.IncertidumbreInterface;
import org.osiris.persistence.controllers.PrioridadInterface;
import org.osiris.persistence.controllers.ProyectoInterface;
import org.osiris.persistence.controllers.SucategoriaInterface;
import org.osiris.persistence.controllers.TipoInterface;
import org.osiris.persistence.controllers.UsuarioInterface;
import org.osiris.persistence.controllers.impl.SubcategoriaJpaController;
import org.osiris.server.utils.AppContext;
import org.springframework.context.ApplicationContext;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

/**
 * The server side implementation of the RPC service.
 */
public class CombosServiceImpl extends RemoteServiceServlet implements
		ComboService {

	/**
	 * 
	 */

	private ApplicationContext ctx = AppContext.getApplicationContext();
	private static final long serialVersionUID = 1L;
	
	
	@Resource
	private ComplejidadInterface complejiddDAO;
	
	@Resource
	private CategoriasInterface categoriaDAO;
	@Resource
	private EstadoInterface estadoDAO;
	
	@Resource
	private IncertidumbreInterface incertidumbreDAO;

	
	@Resource
	private PrioridadInterface prioridadDAO;
	
	private ProyectoInterface proyectoDAO;
	
	
	
	@Resource
	private SucategoriaInterface subcategoriaDAO;
	
	@Resource
	private TipoInterface tipoDAO;
	
	
	@Resource
	private UsuarioInterface usuarioDAO;
	private Logger logger = Logger.getLogger(this.getClass());

	public List<ProyectoViewBean> proyectos = new ArrayList<ProyectoViewBean>();
	public List<CategoriaViewBean> categorias = new ArrayList<CategoriaViewBean>();
	public List<ComplejidadrequisitoViewBean> complejidad = new ArrayList<ComplejidadrequisitoViewBean>();
	public List<IncertidumbreViewBean> incertidumbres = new ArrayList<IncertidumbreViewBean>();
	public List<EstadorequisitoViewBean> estados = new ArrayList<EstadorequisitoViewBean>();
	public List<TipoRequisitoViewBean> tipos = new ArrayList<TipoRequisitoViewBean>();
	public List<UsuarioViewBean> usuarios = new ArrayList<UsuarioViewBean>();
	public List<PrioridadViewBean> prioridad = new ArrayList<PrioridadViewBean>();
	public List<TipoRecursoViewBean> tiposRecurso = new ArrayList<TipoRecursoViewBean>();
	
	@Override
	public List<CategoriaViewBean> getCategorias() {
		if(categoriaDAO==null){
			categoriaDAO=(CategoriasInterface) ctx.getBean("CategoriaJpaController");
		}
		if (categorias.size() == 0) {
			List<Categoria> cats = this.categoriaDAO
					.findCategoriaEntities();
			for (int x = 0; x < cats.size(); x++) {
				CategoriaViewBean cate = new CategoriaViewBean();
				cate.setid(cats.get(x).getIdCategoria());
				cate.setnombre(cats.get(x).getValor());
				categorias.add(cate);
			}
		}
		return categorias;
	}

	@Override
	public List<ComplejidadrequisitoViewBean> getComplejidadRequisito() {
		if(complejiddDAO==null){
			complejiddDAO=(ComplejidadInterface) ctx.getBean("ComplejidadrequisitoJpaController");
		}
		if (complejidad.size() == 0) {
			 List<Complejidadrequisito> cats = this.complejiddDAO.findComplejidadrequisitoEntities();
			for (int x = 0; x < cats.size(); x++) {
				ComplejidadrequisitoViewBean cate = new ComplejidadrequisitoViewBean();
				cate.setid(cats.get(x).getIdComplejidadRequisito());
				cate.setnombre(cats.get(x).getValor());
				complejidad.add(cate);
			}
		}
		return complejidad;
	}

	@Override
	public List<EstadorequisitoViewBean> getEstadosRequisito() {
		if(estadoDAO==null){
			estadoDAO=(EstadoInterface) ctx.getBean("EstadorequisitoJpaController");
		}
		if (estados.size() == 0) {
			 List<Estadorequisito> cats = this.estadoDAO.findEstadorequisitoEntities();
			for (int x = 0; x < cats.size(); x++) {
				EstadorequisitoViewBean cate = new EstadorequisitoViewBean();
				cate.setid(cats.get(x).getIdEstadoRequisito());
				cate.setnombre(cats.get(x).getDescripcion());
				estados.add(cate);
			}
		}
		return estados;
	}

	@Override
	public List<ProyectoViewBean> getProyectos() {
		if(proyectoDAO==null){
			proyectoDAO=(ProyectoInterface) ctx.getBean("ProyectoJpaController");
		}
		if (proyectos.size() == 0) {
			 List<Proyecto> cats = this.proyectoDAO.findProyectoEntities();
			 proyectos.clear();
			for (int x = 0; x < cats.size(); x++) {
				ProyectoViewBean cate = new ProyectoViewBean();
				cate.setidProyecto(cats.get(x).getIdProyecto());
				cate.setnombre(cats.get(x).getNombre());
				proyectos.add(cate);
			}
		}
		return proyectos;
	}

	@Override
	public List<CategoriaViewBean> getSubCategorias(CategoriaViewBean cat) {
		if(subcategoriaDAO==null){
			subcategoriaDAO=(SucategoriaInterface) ctx.getBean("SubcategoriaJpaController");
		}
		if(categoriaDAO==null){
			categoriaDAO=(CategoriasInterface) ctx.getBean("CategoriaJpaController");
		}
		logger.info("Search cat:"+cat);
		if(cat!=null){
			logger.info("Search cat:"+cat.getid());
		}
		Categoria cater = categoriaDAO.findCategoria(cat.getid());
		
		List<CategoriaViewBean> subcategorias = new ArrayList<CategoriaViewBean>();
			 List<Subcategoria> cats = cater.getSubcategoriaList();
			 logger.info("Find "+cats.size()+" subcategorias");
			for (int x = 0; x < cats.size(); x++) {
				CategoriaViewBean cate = new CategoriaViewBean();
					cate.setid(cats.get(x).getIdSubcategoria());
					cate.setpadre(cat);
					cate.setnombre(cats.get(x).getValor());
					logger.info("Find valor:"+cats.get(x).getValor());
					subcategorias.add(cate);
				
			}
		
		return subcategorias;
	}

	@Override
	public List<TipoRequisitoViewBean> getTipos() {
		if(tipoDAO==null){
			tipoDAO=(TipoInterface) ctx.getBean("TiporequisitoJpaController");
		}
		if (tipos.size() == 0) {
			 List<Tiporequisito> cats = this.tipoDAO.findTiporequisitoEntities();
			for (int x = 0; x < cats.size(); x++) {
				TipoRequisitoViewBean cate = new TipoRequisitoViewBean();
				cate.setid(cats.get(x).getIdTipoRequisito());
				cate.setnombre(cats.get(x).getValor());
				tipos.add(cate);
			}
		}
		return tipos;
	}

	@Override
	public List<UsuarioViewBean> getUsuarios() {
		if(usuarioDAO==null){
			usuarioDAO=(UsuarioInterface) ctx.getBean("UsuarioJpaController");
		}
		if (usuarios.size() == 0) {
			 List<Usuario> cats = usuarioDAO.findUsuarioEntities();
			 usuarios.clear();
			for (int x = 0; x < cats.size(); x++) {
				UsuarioViewBean cate = new UsuarioViewBean();
				cate.setidUsuario(cats.get(x).getIdUsuario());
				cate.setnombre(cats.get(x).getNombre()+" "+cats.get(x).getPrimerApellido());
				usuarios.add(cate);
			}
		}
		return usuarios;
	}

	@Override
	public List<IncertidumbreViewBean> getIncertidumbres() {
		if(incertidumbreDAO==null){
			incertidumbreDAO=(IncertidumbreInterface) ctx.getBean("IncertidumbreJpaController");
		}
		if (incertidumbres.size() == 0) {
			  List<Incertidumbre> cats = this.incertidumbreDAO.findIncertidumbreEntities();
			for (int x = 0; x < cats.size(); x++) {
				IncertidumbreViewBean cate = new IncertidumbreViewBean();
				cate.setid(cats.get(x).getIdIncertidumbre());
				cate.setnombre(cats.get(x).getClave());
				incertidumbres.add(cate);
			}
		}
		return incertidumbres;
	}

	@Override
	public List<PrioridadViewBean> getPrioridades() {
		if(prioridadDAO==null){
			prioridadDAO=(PrioridadInterface) ctx.getBean("PrioridadrequisitoJpaController");
		}
		if (prioridad.size() == 0) {
			  List<Prioridadrequisito> cats = this.prioridadDAO.findPrioridadrequisitoEntities();
			for (int x = 0; x < cats.size(); x++) {
				PrioridadViewBean cate = new PrioridadViewBean();
				cate.setid(cats.get(x).getIdPrioridadRequisito());
				cate.setnombre(cats.get(x).getValor());
				prioridad.add(cate);
			}
		}
		return prioridad;
	}

	@Override
	public List<TipoRecursoViewBean> getTiposRecurso() {
		/*
		if(TiporecursoJpaController==null){
			TiporecursoJpaController=(TiporecursoJpaController) ctx.getBean("TiporecursoJpaController");
		}
		if (tiposRecurso.size() == 0) {
			   List<Tiporecurso> cats = this.TiporecursoJpaController.findTiporecursoEntities();
			for (int x = 0; x < cats.size(); x++) {
				TipoRecursoViewBean cate = new TipoRecursoViewBean();
				cate.setid(cats.get(x).getIdTipoRecurso());
				cate.setnombre(cats.get(x).getValor());
				tiposRecurso.add(cate);
			}
		}
		return tiposRecurso;*/
		return null;
	}
}
